Background

swift_dynamicCast() is the runtime support behind the as?, as!, and is
operators. It attempts to convert a source value with a given type into a
destination location with another specified type.

The previous code had evolved over several years into a tangle of different
strategies for different combinations of source and destination types, with a
growing set of inconsistencies between them. The new implementation has a
unified structure that handles common issues with common code to help ensure
consistent behavior.

Design

The new implementation has a main driver called tryCast() that recursively
attempts to find a suitable conversion from source to destination. For
example, if the source is an Any container, tryCast will extract and
recursively try to convert the contents of that container. At each step,
the tryCast will call a function tryCastToXyz that understands specific
requirements for a single target type.

Suppose, for example, you have an Any containing an Optional<Int> and
you want to cast that to a FixedWidthInteger existential:

• tryCast() will ask tryCastToOpaqueExistential if it can convert the Any
  directly. This will fail because Any does not directly conform to any
  protocols.

• tryCast() will extract the Optional<Int> from the Any and try again.

• tryCast() will then try to unwrap the optional. If the optional is nil,
  tryCast will try to initialize the existential with nil and fail.

• Finally, tryCast() will ask tryCastToOpaqueExistential to convert an Int
  to the desired FixedWidthInteger existential. This will succeed and the
  result is returned.

In addition to unwrapping boxed values, tryCast() is also responsible for
other general conversion strategies: using the dynamic type instead of
the static type; invoking Objective-C bridging machinery; packing values
into a __SwiftValue container.

Perhaps most importantly, this PR adds a lot of new tests, including some
"expected failure" tests for issues that aren't (yet) actually fixed.

Resolves SR-1999
Resolves SR-2289 (rdar://27116100)
Resolves SR-4552 (rdar://59174750)
Resolves SR-6126
Resolves SR-8964 (rdar://45217461)
Resolves rdar://58650899

This implementation also does a better job with existential metatypes
and CoreFoundation types.

Next Steps

This PR only changes the runtime dynamic cast code. The Swift compiler
aggressively optimizes casts in release builds, so these changes will
not impact many problems with casting in release builds. I hope to
work on that very soon. In the meantime, you can work around many
compiler problems by calling the following function, which forces
the cast to be handled by the runtime code:

func runtimeCast<T,U>(_ value: T, to: U.Type) -> U? {
  return value as? U
}

// Might use runtime logic or not, depending on compiler optimizations
let b = a as? Foo

// Always uses runtime cast logic
let c = runtimeCast(a, to: Foo.self)

I've not specifically looked at performance. Hopefully, the
new design will make it easier to speed up cast performance in
a future PR.

Caveats

Many casts now succeed that used to fail. Code that relied on certain
casts failing may be surprised. I found and changed one such place
in the standard library.

Different error messages. When a force-cast (as!) fails, the message
may be different, due to the different way in which the new code
tracks and reports failures. I've also taken this opportunity to detect
and issue a specialized error if the cast logic detects an unexpected
null pointer (this can happen when ill-behaved C or Obj-C code returns an
unexpected null pointer).